const cloud = require('wx-server-sdk')

cloud.init({
  env: cloud.DYNAMIC_CURRENT_ENV
})

const db = cloud.database()

/**
 * 版本管理云函数
 * 功能：
 * 1. 获取当前版本信息
 * 2. 更新版本信息
 * 3. 获取版本历史记录
 * 4. 检查版本兼容性
 */
exports.main = async (event, context) => {
  const { action } = event
  
  try {
    switch (action) {
      case 'getCurrentVersion':
        return await getCurrentVersion(event)
      case 'updateVersion':
        return await updateVersion(event)
      case 'getVersionHistory':
        return await getVersionHistory(event)
      case 'checkCompatibility':
        return await checkCompatibility(event)
      default:
        return {
          success: false,
          error: '未知的操作类型'
        }
    }
  } catch (error) {
    console.error('版本管理云函数执行失败:', error)
    return {
      success: false,
      error: error.message || '版本管理操作失败'
    }
  }
}

/**
 * 获取当前版本信息
 */
async function getCurrentVersion(event) {
  try {
    // 查询版本配置集合
    const versionResult = await db.collection('app_versions').where({
      status: 'current'
    }).orderBy('releaseTime', 'desc').limit(1).get()

    if (versionResult.data.length > 0) {
      const currentVersion = versionResult.data[0]
      return {
        success: true,
        data: {
          version: currentVersion.version,
          versionName: currentVersion.versionName,
          buildNumber: currentVersion.buildNumber,
          releaseTime: currentVersion.releaseTime,
          description: currentVersion.description,
          features: currentVersion.features || [],
          bugfixes: currentVersion.bugfixes || [],
          minCompatibleVersion: currentVersion.minCompatibleVersion,
          forceUpdate: currentVersion.forceUpdate || false,
          updateUrl: currentVersion.updateUrl || '',
          changelog: currentVersion.changelog || ''
        }
      }
    } else {
      // 如果数据库中没有版本信息，返回默认版本
      const defaultVersion = {
        version: '1.0.0',
        versionName: '正式版',
        buildNumber: '20250101',
        releaseTime: new Date(),
        description: '数智匠心工程管理平台正式版',
        features: [
          '完整的工程服务管理功能',
          '用户权限管理系统',
          '订单流程管理',
          '施工队伍管理',
          '实时通知系统'
        ],
        bugfixes: [],
        minCompatibleVersion: '1.0.0',
        forceUpdate: false,
        updateUrl: '',
        changelog: '正式版发布'
      }

      // 初始化版本记录
      await initializeVersionRecord(defaultVersion)

      return {
        success: true,
        data: defaultVersion
      }
    }
  } catch (error) {
    console.error('获取当前版本失败:', error)
    return {
      success: false,
      error: '获取版本信息失败'
    }
  }
}

/**
 * 更新版本信息
 */
async function updateVersion(event) {
  try {
    const { versionData } = event

    if (!versionData || !versionData.version) {
      return {
        success: false,
        error: '版本信息不完整'
      }
    }

    // 将当前版本标记为历史版本
    await db.collection('app_versions').where({
      status: 'current'
    }).update({
      data: {
        status: 'history',
        updatedTime: new Date()
      }
    })

    // 添加新版本记录
    const newVersionData = {
      ...versionData,
      status: 'current',
      releaseTime: versionData.releaseTime || new Date(),
      createdTime: new Date(),
      updatedTime: new Date()
    }

    const result = await db.collection('app_versions').add({
      data: newVersionData
    })

    return {
      success: true,
      data: {
        versionId: result._id,
        version: newVersionData.version,
        message: '版本更新成功'
      }
    }
  } catch (error) {
    console.error('更新版本失败:', error)
    return {
      success: false,
      error: '更新版本信息失败'
    }
  }
}

/**
 * 获取版本历史记录
 */
async function getVersionHistory(event) {
  try {
    const { limit = 10, skip = 0 } = event

    const result = await db.collection('app_versions')
      .orderBy('releaseTime', 'desc')
      .skip(skip)
      .limit(limit)
      .get()

    return {
      success: true,
      data: {
        versions: result.data,
        total: result.data.length,
        hasMore: result.data.length === limit
      }
    }
  } catch (error) {
    console.error('获取版本历史失败:', error)
    return {
      success: false,
      error: '获取版本历史失败'
    }
  }
}

/**
 * 检查版本兼容性
 */
async function checkCompatibility(event) {
  try {
    const { clientVersion } = event

    if (!clientVersion) {
      return {
        success: false,
        error: '客户端版本号不能为空'
      }
    }

    // 获取当前服务器版本
    const currentVersionResult = await getCurrentVersion(event)
    if (!currentVersionResult.success) {
      return currentVersionResult
    }

    const serverVersion = currentVersionResult.data
    const isCompatible = compareVersions(clientVersion, serverVersion.minCompatibleVersion) >= 0
    const needsUpdate = compareVersions(clientVersion, serverVersion.version) < 0

    return {
      success: true,
      data: {
        isCompatible,
        needsUpdate,
        forceUpdate: serverVersion.forceUpdate && needsUpdate,
        currentVersion: clientVersion,
        latestVersion: serverVersion.version,
        minCompatibleVersion: serverVersion.minCompatibleVersion,
        updateInfo: needsUpdate ? {
          version: serverVersion.version,
          description: serverVersion.description,
          features: serverVersion.features,
          bugfixes: serverVersion.bugfixes,
          changelog: serverVersion.changelog
        } : null
      }
    }
  } catch (error) {
    console.error('检查版本兼容性失败:', error)
    return {
      success: false,
      error: '检查版本兼容性失败'
    }
  }
}

/**
 * 初始化版本记录
 */
async function initializeVersionRecord(versionData) {
  try {
    await db.collection('app_versions').add({
      data: {
        ...versionData,
        status: 'current',
        createdTime: new Date(),
        updatedTime: new Date()
      }
    })
    console.log('版本记录初始化成功')
  } catch (error) {
    console.error('初始化版本记录失败:', error)
  }
}

/**
 * 版本号比较函数
 * 返回值：
 * 1: version1 > version2
 * 0: version1 = version2
 * -1: version1 < version2
 */
function compareVersions(version1, version2) {
  const v1Parts = version1.split('.').map(Number)
  const v2Parts = version2.split('.').map(Number)
  
  const maxLength = Math.max(v1Parts.length, v2Parts.length)
  
  for (let i = 0; i < maxLength; i++) {
    const v1Part = v1Parts[i] || 0
    const v2Part = v2Parts[i] || 0
    
    if (v1Part > v2Part) return 1
    if (v1Part < v2Part) return -1
  }
  
  return 0
} 